﻿//#define _CRT_SECURE_NO_WARNINGS  
//#include <stdio.h>
//#include <stdlib.h>
//#include <string.h>
//
////  整型排序
//int compare_int(const void* a, const void* b) {
//    return (*(int*)a - *(int*)b); 
//}
//
//void demo_int_sort() {
//    int arr[] = { 5, -3, 8, 2, -10, 0 };
//    size_t n = sizeof(arr) / sizeof(arr[0]);
//
//    printf("整型排序前：");
//    for (size_t i = 0; i < n; i++) printf("%d ", arr[i]);
//
//    qsort(arr, n, sizeof(int), compare_int);
//
//    printf("\n整型排序后：");
//    for (size_t i = 0; i < n; i++) printf("%d ", arr[i]);
//    printf("\n\n");
//}
//
////  字符串排序
//int compare_str(const void* a, const void* b) {
//    return strcmp(*(const char**)a, *(const char**)b); 
//}
//
//void demo_str_sort() {
//    const char* fruits[] = {
//        "Apple", "banana", "Cherry", "date",
//        "apricot", "Blueberry"
//    };
//    size_t n = sizeof(fruits) / sizeof(fruits[0]);
//
//    printf("字符串排序前：\n");
//    for (size_t i = 0; i < n; i++) printf("%s\n", fruits[i]);
//
//    qsort(fruits, n, sizeof(char*), compare_str);
//
//    printf("\n字符串排序后（区分大小写）：\n");
//    for (size_t i = 0; i < n; i++) printf("%s\n", fruits[i]);
//    printf("\n");
//}
//
////  结构体排序 
//typedef struct {
//    char name[50];
//    int age;
//    double salary;
//} Employee;
//
//// 按年龄升序排序
//int compare_employee_age(const void* a, const void* b) {
//    return ((Employee*)a)->age - ((Employee*)b)->age;
//}
//
//// 按姓名不区分大小写排序
//int compare_employee_name(const void* a, const void* b) {
//    return _stricmp(((Employee*)a)->name, ((Employee*)b)->name);
//}
//
//void demo_struct_sort() {
//    Employee staff[] = {
//        {"Alice", 32, 8500.0},
//        {"bob", 25, 6500.5},
//        {"Charlie", 45, 12000.0},
//        {"david", 28, 7200.0}
//    };
//    size_t n = sizeof(staff) / sizeof(staff[0]);
//
//    // 按年龄排序
//    qsort(staff, n, sizeof(Employee), compare_employee_age);
//    printf("按年龄排序：\n");
//    for (size_t i = 0; i < n; i++) {
//        printf("%-8s %2d ¥%.2f\n",
//            staff[i].name, staff[i].age, staff[i].salary);
//    }
//
//    // 按姓名排序（不区分大小写）
//    qsort(staff, n, sizeof(Employee), compare_employee_name);
//    printf("\n按姓名排序：\n");
//    for (size_t i = 0; i < n; i++) {
//        printf("%-8s %2d ¥%.2f\n",
//            staff[i].name, staff[i].age, staff[i].salary);
//    }
//}
//
//int main() {
//    demo_int_sort();    // 整型排序演示
//    demo_str_sort();    // 字符串排序演示
//    demo_struct_sort(); // 结构体排序演示
//    return 0;
//}

#define _CRT_SECURE_NO_WARNINGS  
#include <stdio.h>
#include <string.h>

void bubble_sort(void* base, size_t nmemb, size_t size,
    int (*compar)(const void*, const void*)) {
    if (!base || nmemb < 1 || size < 1 || !compar) return;

    char* char_base = (char*)base;  
    int swapped;                    

    for (size_t end = nmemb - 1; end > 0; end--) {
        swapped = 0;
        for (size_t i = 0; i < end; i++) {
           
            char* current = char_base + i * size;
            char* next = char_base + (i + 1) * size;

         
            if (compar(current, next) > 0) {
        
                for (size_t j = 0; j < size; j++) {
                    char temp = current[j];
                    current[j] = next[j];
                    next[j] = temp;
                }
                swapped = 1;
            }
        }
        if (!swapped) break;  
    }
}

// ================= 测试案例 =================

// 整型比较函数（升序）
int compare_int(const void* a, const void* b) {
    return *(const int*)a - *(const int*)b;
}

// 字符串比较函数（字典序）
int compare_str(const void* a, const void* b) {
    return strcmp(*(const char**)a, *(const char**)b);
}

// 结构体定义与比较函数
typedef struct {
    int id;
    char name[20];
} Person;

int compare_person(const void* a, const void* b) {
    return ((const Person*)a)->id - ((const Person*)b)->id;
}

int main() {
    // 测试1：整型数组排序
    int nums[] = { 5, -3, 8, 2, -10, 0 };
    size_t num_size = sizeof(nums) / sizeof(nums[0]);
    bubble_sort(nums, num_size, sizeof(int), compare_int);
    printf("整型排序结果：");
    for (size_t i = 0; i < num_size; i++) printf("%d ", nums[i]);

    // 测试2：字符串数组排序
    const char* fruits[] = { "Apple", "banana", "Cherry", "date" };
    size_t str_size = sizeof(fruits) / sizeof(fruits[0]);
    bubble_sort(fruits, str_size, sizeof(char*), compare_str);
    printf("\n\n字符串排序结果：\n");
    for (size_t i = 0; i < str_size; i++) printf("%s\n", fruits[i]);

    // 测试3：结构体排序
    Person people[] = { {3, "Alice"}, {1, "Bob"}, {2, "Charlie"} };
    size_t person_size = sizeof(people) / sizeof(people[0]);
    bubble_sort(people, person_size, sizeof(Person), compare_person);
    printf("\n结构体排序结果：\n");
    for (size_t i = 0; i < person_size; i++)
        printf("ID: %2d, Name: %s\n", people[i].id, people[i].name);

    return 0;
}